﻿using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection.Emit;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using static System.Net.Mime.MediaTypeNames;

namespace AsyncTest
{
    internal class Program
    {
        static async Task Main(string[] args)
        {
            // 同步方法调用异步方法
            await CallAsyncMethod();

            ProcessStartInfo ps = new ProcessStartInfo("E:\\xpl\\project\\SunnyUI-master\\SunnyUI.Demo\\Bin\\SunnyUI.Demo.exe");
            ps.WindowStyle = ProcessWindowStyle.Normal;

            Process process = new Process();
            process.StartInfo = ps;
            process.Start();
            process.WaitForExit();
            try
            {
                await LongRunningOperationWithTimeoutAsync(TimeSpan.FromSeconds(5)); // 设置5秒超时
                Console.WriteLine("操作完成");
            }
            catch (TimeoutException)
            {
                Console.WriteLine("操作超时");
            }
            string versionInfo=loadVer();
            Console.WriteLine(versionInfo);
            Console.ReadLine();
        }
        // 异步方法
        static async Task<int> AsyncMethod()
        {
            Console.WriteLine("异步方法开始执行...");

            // 模拟异步操作，比如从数据库或远程服务获取数据
            await Task.Delay(2000);

            Console.WriteLine("异步方法执行完成。");

            return 43;
        }

        // 同步方法调用异步方法
        static async Task CallAsyncMethod()
        {
            Console.WriteLine("同步方法开始执行...");

            // 使用await等待异步方法完成
            int result = await AsyncMethod();

            Console.WriteLine($"异步方法返回的结果为: {result}");

            Console.WriteLine("同步方法执行完成。");
        }
        //========================================================
        public static async Task LongRunningOperationWithTimeoutAsync(TimeSpan timeout)
        {
            using (var cts = new CancellationTokenSource())
            {
                var delayTask = Task.Delay(timeout, cts.Token); // 设置超时任务
                var longRunningTask = LongRunningOperationAsync(cts.Token); // 长时间运行的任务
                var completedTask = await Task.WhenAny(delayTask, longRunningTask); // 等待任意一个任务完成
                if (completedTask == delayTask) // 如果超时任务完成，则抛出异常或取消长时间运行的任务
                {
                    cts.Cancel(); // 取消长时间运行的任务，抛出OperationCanceledException异常，可以通过catch捕获并转换为TimeoutException或其他自定义异常。
                    throw new TimeoutException("操作超时"); // 或者直接抛出TimeoutException异常。
                }
                await longRunningTask; // 如果长时间运行的任务完成了，则等待它完成。如果这里不等待，可能会导致程序提前退出。
            }
        }
        public static async Task LongRunningOperationAsync(CancellationToken token)
        {
            // 模拟一个长时间运行的操作
            await Task.Delay(10000, token); // 这个任务预计运行10秒
        }

        public static string GetEdition()
        {
            Version version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
            return string.Format("{0}.{1}.{2}.{3}", version.Major, version.Minor.ToString("00"), version.Build.ToString("00"), version.Revision.ToString());
        }

        public static string loadVer()
        {
            string result = string.Empty;
            string ver = GetEdition();
            result = "Test" + " - V" + ver;
            //label2.Text = $"Run path: <{Application.StartupPath}> 型号:{Machine.Instance.CurrentProduct}";
            result = "Software Version: " + ver;

            return result;
        }
    }
}
